home *** CD-ROM | disk | FTP | other *** search
/ Software 2000 / Software 2000 Volume 1 (Disc 1 of 2).iso / utilities / u293.dms / in.adf / FutureSound / iffroutines.c < prev    next >
Encoding:
C/C++ Source or Header  |  1987-06-20  |  4.1 KB  |  179 lines
  1. /*
  2.    These routines provide limited IFF support for FutureSound.
  3.    They will read and write single octave one-shot sounds.
  4.  
  5.    Additional octave and repeat support may be added later.
  6.  
  7.    Based on the "8SVX" IFF 8-Bit Sampled Voice document dated
  8.    Febuary 7, 1985.
  9.  
  10.    Routines:
  11.  
  12.       ULONG SizeIFF(Filename)
  13.       char *Filename;      File to open 
  14.  
  15.          returns size of sample or 0 if error.
  16.  
  17.  
  18.       UWORD ReadIFF(Filename,Buffer)
  19.       char *Filename;      File to read
  20.       BYTE *Buffer;       Buffer to read sample into
  21.  
  22.          returns the record rate;
  23.  
  24.    Dan Lovy    May 1986
  25.  
  26.    Modified for use with FutureSound auxiliary routines - June 1986
  27.       by Ralph Hebb
  28.  
  29.    Converted to use AmigaDOS I/O calls, John Foust, 6/22/86
  30.  
  31. */
  32.  
  33. /* for comments see IFF spec,  I'm too tired to type them in now */
  34.  
  35. #include "stdio.h"
  36. #include "exec/types.h"
  37. #include "SoundErrors.h"
  38.  
  39. #include "libraries/dosextens.h"
  40.  
  41. extern struct FileHandle *Open();
  42.  
  43. typedef LONG Fixed;
  44.  
  45. #define Unity 0x10000L
  46. #define sCmpNone      0
  47. #define sCmpFibDelta   1
  48.  
  49. typedef struct {
  50.    ULONG   oneShotHiSamples,   /* # samples in the high octave 1-shot part */
  51.          repeatHiSamples,   /* # samples in the high octave repeat part */
  52.          samplesPerHiCycle;   /* # samples/cycle in high octave, else 0   */
  53.    UWORD   samplesPerSec;      /* data sampling rate */
  54.    UBYTE   ctOctave,         /* number of octaves of waveforms */
  55.          sCompression;      /* data compression technique used */
  56.    Fixed   volume;            /* playback volume from 0 to Unity */
  57.  
  58.    } Voice8Header;
  59.  
  60. ULONG SizeIFF(Filename)
  61. char *Filename;      /* File to open */
  62. /* returns size of sample or 0 if error. */
  63. {
  64.  
  65. /*   FILE *fp; */
  66. struct FileHandle *fp;
  67.  
  68.    char *ckname = "    ";
  69.    LONG dummy;
  70.    Voice8Header Header;
  71.  
  72.    if (fp = Open(Filename,MODE_OLDFILE))
  73.    {
  74.       Read(fp,ckname,4);
  75.       if (strcmp(ckname,"FORM")==0)
  76.       {
  77.          Read(fp,ckname,4);   /* two calls, eat 8 chars */
  78.          Read(fp,ckname,4);
  79.          if (strcmp(ckname,"8SVX")==0)
  80.          {
  81.             get_to("VHDR",fp);
  82.             Read(fp,&dummy,sizeof(LONG));
  83.             Read(fp,&Header,sizeof(Header));
  84.             Close(fp);
  85.             return(Header.oneShotHiSamples+
  86.                   Header.repeatHiSamples);
  87.          }
  88.          else
  89.          {
  90.             Close(fp);
  91.             return(0);      
  92.          }
  93.       }
  94.       else
  95.       {
  96.          Close(fp);
  97.          return(0);      
  98.       }
  99.    }
  100.    else
  101.    {
  102.       return(0);
  103.    }
  104. }
  105.  
  106. UWORD ReadIFF(Filename,IFFBuf0)
  107. char *Filename;      /* File to read */
  108. BYTE *IFFBuf0;         /* Buffer to read sample into */
  109. /* returns the record rate */
  110. {
  111. /* FILE *fp; */
  112.    struct FileHandle *fp;
  113.    char *ckname = "    ";
  114.    LONG dummy;
  115.    Voice8Header Header;
  116.  
  117.    if (fp = Open(Filename,MODE_OLDFILE))
  118.    {
  119.       Read(fp,ckname,4);
  120.       if (strcmp(ckname,"FORM")==0)
  121.       {
  122.          Read(fp,ckname,4);      /* two calls, eat 8 chars */
  123.          Read(fp,ckname,4);
  124.          if (strcmp(ckname,"8SVX")==0)
  125.          {
  126.             get_to("VHDR",fp);
  127.             Read(fp,&dummy,sizeof(LONG));
  128.             Read(fp,&Header,sizeof(Header));
  129.             get_to("BODY",fp);
  130.             Read(fp,&dummy,sizeof(LONG));
  131.             Read(fp,IFFBuf0,Header.oneShotHiSamples+
  132.                  Header.repeatHiSamples);
  133.             Close(fp);
  134.             return(Header.samplesPerSec);
  135.          }
  136.          else
  137.          {
  138.             Close(fp);
  139.             return(Error(IFF_ERROR,Filename));      
  140.          }
  141.       }
  142.       else
  143.       {
  144.          Close(fp);
  145.          return(Error(IFF_ERROR,Filename));      
  146.       }
  147.    }
  148.    else
  149.    {
  150.       return(Error(OPEN_ERROR,Filename));
  151.    }
  152. } 
  153.  
  154. /* this routine walks through the iff file looking for chunks */
  155. get_to(ckname,fp)
  156. char *ckname;
  157. /* FILE *fp; */
  158. struct FileHandle *fp;
  159. {
  160.    char *ckcheck = "    ";
  161.    int  skip,i,dummy;
  162.    int numread = 1;
  163.  
  164.    while(numread!=0)       /* !feof(fp)) */
  165.    {
  166.       Read(fp,ckcheck,4);
  167.       if (strcmp(ckname,ckcheck)==0)
  168.       {
  169.          return(1);
  170.       }
  171.       numread = Read(fp,&skip,sizeof(LONG));
  172.       for (i=0; i<skip; i++)
  173.       {
  174.          numread = Read(fp,&dummy,1);
  175.       }
  176.    }
  177. }
  178.  
  179.